package com.gxc.array;

import java.util.LinkedList;
import java.util.Queue;
import java.util.Scanner;

/**
 * 存在一个 m*n 的二维数组，其成员取值范围为 0，1，2。其中值为1的元素具备同化特性，每经过 1S，将上下左右值为0的元素同化为1，而值为2的元素，免疫同化。将数组所有成员随机初始化为0或2，再将矩阵的[0,0]元素修改为1，在经过足够长的时间后，求矩阵中有多少个元素是0或2（即0和2数量之和）。
 *
 * 输入描述
 * 输入的前两个数字是矩阵大小。后面的数字是矩阵内容。
 *
 * 备注
 * m和n不会超过30（包含30）。
 * 输出描述
 * 返回数字中非1的元素个数
 */
public class Assimilation {

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int m = scanner.nextInt();
        int n = scanner.nextInt();

        int[][] array = new int[m][n];
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                array[i][j] = scanner.nextInt();
            }
        }
        scanner.close();

        bfs(array, m, n);

        int res = 0;
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                if (array[i][j] != 1) {
                    res++;
                }
            }
        }
        System.out.println(res);
    }

    private static void bfs(int[][] array, int m, int n) {
        int[][] directions = {{-1, 0}, {1, 0}, {0 ,-1}, {0, 1}};
        Queue<int[]> queue = new LinkedList<>();
        queue.add(new int[]{0, 0});
        array[0][0] = 1;

        while (!queue.isEmpty()) {
            int[] posion = queue.poll();

            for (int i = 0; i < directions.length; i++) {
                int[] direction = directions[i];
                int x = posion[0] + direction[0];
                int y = posion[1] + direction[1];
                if (x>=0 && x<m && y>=0 && y<n && array[x][y] == 0) {
                    array[x][y] = 1;
                    queue.add(new int[]{x, y});
                }
            }
        }
    }
}
